import PageHeader from '@/components/PageHeader';
import { submitForm } from '@/services/form';
import { Field, Form, Input, Message, ResponsiveGrid, Radio, Tab, Timeline, Card } from '@alifd/next';
import { definePageConfig, history, useNavigate, useSearchParams } from 'ice';
import { useCallback, useEffect, useState } from 'react';
import createDaily from './createDaily';
import { get, post } from '@/utils/request';
import { ChooseTable } from '@/components/ChooseTable';
import ResultTable from './ResultTable';
import TimerUpdate from './TimerUpdate';
import dahai from 'common_library/dahai';
const dahaiProject = dahai.createProject('decision', 'daily');
const { Cell } = ResponsiveGrid;
const FormItem = Form.Item;
const RadioGroup = Radio.Group;
const TimelineItem = Timeline.Item;
const TitleList = (props) => {
    const navigate = useNavigate();
    let value = props.list.find(item => {
        return item.active;
    });
    return <RadioGroup
        dataSource={props.list}
        shape="button"
        value={value ? value.value : null}
        onChange={(value) => {
            location.href = `/daily?date=${value}`;
            props.onChange && props.onChange(value);
        }}
    />
}
function createDefaultData(list) {
    return list.map(title => {
        return {
            title,
            data: {
                robotList: [],
                humanList: []
            }
        }
    })
}
export default function DailyPlan() {
    const [searchParams, setSearchParams] = useSearchParams();
    const onSubmit = async (values: Record<string, any>) => {
        submitForm(values).then(() => {
            Message.success('提交成功');
        });
    };
    useEffect(() => {
    }, []);
    const [hasInit, setHasInit] = useState(false);
    const field = Field.useField();
    const [list, setList] = useState<any>([]);
    const [note, setNote] = useState<any>('');
    const [timeLineList, setTimeLineList] = useState<any>(null);
    const [resultExtraInfo, setResultExtraInfo] = useState<any>({});
    const [titleList, setTitleList] = useState(createDaily(searchParams.get('date')));
    useEffect(() => {
        let currentDate = searchParams.get('date');
        dahaiProject.getFileContent(currentDate).then(data => {
            if (!data) {
                let preDate = titleList.currentChoose ? titleList.currentChoose.pre : null;
                if (preDate) {
                    dahaiProject.getFileContent(preDate).then(data => {
                        if (!data) {
                            setList(createDefaultData(['生活']));
                        } else {
                            const timeList = getTimelineList(data.list);
                            data.list = data.list.map(item => {
                                item.data.humanList = item.data.humanList.map(item2 => {
                                    item2.timeRange = null;
                                    return item2;
                                })
                                item.data.robotList = item.data.humanList.map(item2 => {
                                    item2.timeRange = null;
                                    return item2;
                                })
                                return item;
                            });
                            setList(data.list);
                            // let extraInfo = data.extraInfo;
                            // let keys = Object.keys(extraInfo);
                            // for (let i = 0; i < keys.length; i++) {
                            //     let extraKey = keys[i];
                            //     // 看看extra里面是否存在，不存在就删除了
                            //     let hasOne = timeList.find(item => {
                            //         return item.id == extraKey;
                            //     });
                            //     if (!hasOne) {
                            //         delete extraInfo[extraKey];
                            //     }
                            // }
                            // setResultExtraInfo(extraInfo);

                        }
                        setTimeout(() => {
                            setHasInit(true);
                        }, 1000);

                    });
                } else {
                    setList(createDefaultData(['生活']));
                    setTimeout(() => {
                        setHasInit(true);
                    }, 1000);
                }
            } else {
                setList(data.list);
                setNote(data.note);
                setResultExtraInfo(data.extraInfo);
                setTimeout(() => {
                    setHasInit(true);
                }, 1000);
            }
        });
    }, []);
    useEffect(() => {
        updateTimeLineList();
    }, [list, resultExtraInfo, note]);
    const getTimelineList = (list) => {
        let timeList = [];
        if (list.length > 0) {
            list.forEach(element => {
                let data = element.data;
                if (data.humanList) {
                    data.humanList.forEach(item => {
                        if (item.timeRange) {
                            timeList.push({
                                id: item.id,
                                title: item.detail,
                                time: item.timeRange
                            });
                        }
                    });
                }
                if (data.robotList) {
                    data.robotList.forEach(item => {
                        if (item.timeRange) {
                            timeList.push({
                                id: item.id,
                                title: item.detail,
                                time: item.timeRange
                            });
                        }
                    });
                }
            });
        }
        return timeList;
    }
    const updateTimeLineList = () => {
        let timeList = getTimelineList(list);
        setTimeLineList(timeList.sort((item1, item2) => {
            return item1.time[0] < item2.time[0] ? -1 : 1;
        }));

        let isOk = true;
        timeList.forEach((item) => {
            // if (resultExtraInfo[item.id]) {
            //     console.log(resultExtraInfo[item.id].bad, resultExtraInfo[item.id].good, '=============1111111111111');
            // } else {
            //     console.log(resultExtraInfo, item.id, resultExtraInfo[item.id], '==========================');
            // }
            let extraKey = item.id;
            if (!resultExtraInfo[extraKey]) {
                resultExtraInfo[extraKey] = {};
                isOk = false;
            } else {
                if (!(resultExtraInfo[extraKey].bad
                    && resultExtraInfo[extraKey].good
                    && JSON.stringify(resultExtraInfo[extraKey].bad).trim().length > 10
                    && resultExtraInfo[extraKey].good.trim().length > 10
                )) {
                    isOk = false;
                }
            }
        });
        if (note.trim() == '') {
            isOk = false;
        }
        // for (let i = 0; i < list.length; i++) {
        //     if ((!list[i].data || !list[i].data.iwant) || (list[i].data && list[i].data.iwant && list[i].data.iwant.trim() == '')) {
        //         isOk = false;
        //         break;
        //     }
        // }
        if (hasInit) {
            let currentDate = searchParams.get('date');
            dahaiProject.updateFileContent(currentDate, {
                list,
                note: note,
                extraInfo: resultExtraInfo,
                extraInfoOk: isOk,
            });
        }
    }
    return (
        <ResponsiveGrid gap={20} style={{
            paddingBottom: '100px'
        }}>
            <Cell colSpan={12}>
                <PageHeader
                    title="唯一的思考方式：先选择后思考，先开心，后解决，先选择那个让你开心放心的，然后思考解决那些让你担心的, 思考是用来解决问题的，而不是用来权衡利弊的，满意之后不思考，否则就是走下坡路，人身本质就是一个限时项目，对于那些你确定的事情，越早决定越好，早点做，你可以去完成剩下未完成的事情，这是一个效率和时间的竞争"
                    description={
                        <div>
                            <TitleList onChange={(value) => {
                                // setTitleList(createDaily(value));
                            }} list={titleList.yearList}></TitleList>
                            <TitleList onChange={(value) => {
                                // setTitleList(createDaily(value));
                            }} list={titleList.monthList}></TitleList>
                            <br />
                            <TitleList onChange={(value) => {
                                // setTitleList(createDaily(value));
                            }} list={titleList.weekList}></TitleList>
                            <br />
                            <TitleList onChange={(value) => {
                                // setTitleList(createDaily(value));
                            }} list={titleList.dayList}></TitleList>
                        </div>
                    }
                    breadcrumbs={[{
                        name: <div>
                            {`日常计划-以前的成功是偶然的，失败是必然的，因为你不敢对自己满意的事情做出决定，而且还要继续怀疑和对比？`}
                            <TimerUpdate onEndTime={() => {
                                dahaiProject.updateFileContent('updateAlreadyNote', {
                                    [searchParams.get('date')]: true
                                });
                            }}></TimerUpdate>
                        </div>
                    }]}
                />
            </Cell>
            <Cell colSpan={12}>
                <Input.TextArea autoHeight={{
                    minRows: 2,
                    maxRows: 10
                }} value={note} onChange={(value) => {
                    setNote(value);
                }} placeholder='今天的日记，锻炼身体，洗洗刷刷，是你成功的唯一出路，写写你今天整理了什么，锻炼了什么' style={{
                    width: '100%'
                }}></Input.TextArea>
                {(list.length > 0 && timeLineList) && <Tab
                    defaultActiveKey={timeLineList.length > 0 ? 'timeLine' : list[0].title}
                    extra={
                        <Form style={{
                            width: '300px'
                        }} className="filter-form" responsive fullWidth labelAlign={'left'} field={field}>
                            <FormItem colSpan={8}>
                                <Input name="newtitle" placeholder="请输入" />
                            </FormItem>
                            <FormItem>
                                <Form.Submit type="primary" onClick={() => {
                                    list.push(createDefaultData([field.getValue('newtitle')])[0]);
                                    field.resetToDefault();
                                    setList([...list]);
                                }} validate style={{ marginRight: 10 }}>
                                    提交
                                </Form.Submit>
                            </FormItem>
                        </Form>
                    }
                    shape="wrapped"
                    onClose={(title) => {
                        let tempList = list.filter(item => {
                            return item.title != title;
                        });
                        setList(tempList);
                    }}
                    style={{ marginTop: 10 }}
                >
                    <Tab.Item title={'时间线'} key={'timeLine'} closeable={false}>
                        <ResultTable dataSource={timeLineList} extraInfo={resultExtraInfo} onChange={(extraInfo: any) => {
                            setResultExtraInfo(extraInfo);
                        }}></ResultTable>
                        {/* <Timeline style={{
                            marginTop: '15px'
                        }}>
                            {timeLineList.map(item => {
                                return <TimelineItem title={item.title} time={
                                    `${item.time[0]}-${item.time[1]}`
                                } state="process" />
                            })}
                        </Timeline> */}
                    </Tab.Item>
                    {list.map((item, index) => (
                        <Tab.Item title={item.title} key={item.title} closeable={true}>
                            <ChooseTable title={item.title} onChange={(data: any) => {
                                list[index] = {
                                    title: list[index].title,
                                    data: data
                                }
                                setList([...list]);
                            }} iwant={item.data.iwant} humanList={item.data.humanList} robotList={item.data.robotList}></ChooseTable>
                        </Tab.Item>
                    ))}
                </Tab>}
                <Card free title="提醒">
                    <div style={{
                        padding: '20px'
                    }}>
                        <dl >
                            <dt>我过去不幸的三大灾难, 满意之后的等待，就是等死，满意之后的寻找，就是寻死</dt>
                            <dd>不敢相信自己，有利的事不敢做，有坏的事不敢等，总喜欢去问别人，实际上，满意之后的路，都是下坡路，害怕之后的路，都是黄泉路</dd>
                            <dd>喜欢顺利成章，水到渠成，这是自然科学的道理，但是人文世界，实际是：要么欺骗，要么强制，不在乎要主动这么做，但是如果刚好别人能被你欺骗，能被你强制，你一定要抓住机会</dd>
                            <dd>给水平差的亲人，留空间，留尊严，当人看，你明明知道对方水平很低，不应该当人看，但是你还要把对方当人看，人和狗的区别不是生物划分的，而是意识层面划分的，没有价值观的人，还不如一条狗</dd>
                        </dl>
                        <dl style={{
                            marginTop: 0
                        }}>
                            <dt>不要被动的去规划和决定，一切都要按你主动的规划去走（成本意识）（我大哥强人所难，而且不讲信用，2024.11.22 彻底拉黑）虽然担心大哥公司不转让给你，但是实际就算他这样做你的成本也才2000块钱，不能因为这个，你反而付出了1万的成本</dt>
                            <dd>这个世界最危险的事情，就是把自己暂时不需要的东西，借给别人，帮助别人，一旦这样做了，你就走上沉默成本，被人牵着走的命运，什么情况下可以帮助别人，只有自己主动帮助别人，别人的所有请求都只能拒绝，因为如果你相帮就早帮了</dd>
                            <dd>不能因为错过了房子，就随便选一个房子</dd>
                            <dd>不能因为但茜现在在上学，就放过他，一直等，你可以按照之前的想法，直接逼她还钱，就范</dd>
                            <dd>不能因为你大哥需要手机，需要钱，你就委屈自己，感觉重新买一个也可以，或者借他钱也行</dd>
                        </dl>
                        <dl style={{
                            marginTop: 0
                        }}>
                            <dt>人类的价值在于分清主次</dt>
                            <dd>忽略缺点：非主线的缺点要忽略，这是代价，是以后要处理的</dd>
                            <dd>主动投入：主线的投入要舍得，因为你不缺</dd>
                            <dd>接受损失：非主线的损失要接受，因为你做了非主线的事情，就会有不可预期的损失，本来这些损失如果是主线，你是能接受的，但是这是非主线的，你想尽可能降低成本，你反而会觉得损失很大，所以这个时候要接受</dd>
                        </dl>
                        <dl style={{
                            marginTop: 0
                        }}>
                            <dt>分清当下需要和未来需要</dt>
                            <dd>当下需要没有的东西：要求要低，只要能满足你的最低要求，你就应该全力以赴，不要用未来非常好的状态，来要求初级入门的学徒</dd>
                            <dd>当下需要已经有的东西：没有要求，只能尽可能利用其优点，你已经选定，要愿赌服输</dd>
                            <dd>未来需要而且重要的东西（钱，计划）：当下别看的太重，只要能满足你未来的最低要求，你就应该全力以赴的主动付出，但是未来要看的很重，所以你要学会投资（钱，时间，精力）</dd>
                        </dl>
                        <dl style={{
                            marginTop: 0
                        }}>
                            <dt>总结：上面三个全部包含在这里面</dt>
                            <dd>不要去思考当下没有，想要的东西，而是应该珍惜当下的条件，努力的说服自己去做当下能做，而且想做的事情，要知道说服自己去投资自己想要的事情，本来需要很大的勇气</dd>
                            <dd>局中人不思考，因为局中人的逻辑都完美无缺，但是局中人的感觉正确度是0%，所以虽然逻辑链路是对的，但是前提条件是错的，所以结果就100%错误</dd>
                            <dd>不要去考虑后果，一旦考虑后果，就会沦为畜生，因为人的价值就在于解决问题，你只能先做那些你确定正确的，然后不断的修补漏洞</dd>
                            <dd>如果你被别人影响，就要过别人的生活，每个人的生活都是他思维决定的，他现在什么样的生活，都是由器当下的思维决定的</dd>
                            <dd>心动就心动，因为心动的东西，至少是不败的，而人生拼的不是正确，而是时间</dd>
                        </dl>
                    </div>
                </Card>
            </Cell>
        </ResponsiveGrid>
    );
}

export const pageConfig = definePageConfig(() => {
    return {
        auth: ['admin', 'user'],
        title: '日常计划',
    };
});
